package OfferAliBaBa.a_21年阿里笔试;

import java.io.*;
import java.util.*;

public class Main1 {
    //排序器，将X从小到大排序，最关键的一步是将相同的X按Y从大到小排序，因为如果按Y从小到大排序，
    //会导致后面的大的Y覆盖末尾前面的小的Y，这样就不符合贪心算法的尽量保证末尾元素最小的要求了。
    private static Comparator<int[]> comparator = new Comparator<int[]>() {
        @Override
        public int compare(int[] thisObject, int[] otherObject) {
            if (thisObject[0] > otherObject[0]) return 1;
            else if (thisObject[0] < otherObject[0]) return -1;
            else {
                if (thisObject[1] > otherObject[1]) return -1;
                else if (thisObject[1] == otherObject[1]) return 0;
                else return 1;
            }
        }
    };

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String count_str = bf.readLine();

        int count = Integer.parseInt(count_str);

        for (int i = 0; i < count; i++) {

            String lengthNumber_str = bf.readLine();
            int row = Integer.parseInt(lengthNumber_str);
            String[] str2 = bf.readLine().split(" ");
            String[] str3 = bf.readLine().split(" ");
            int[][] items = new int[row][2];

            for (int j = 0; j < row; j++) {
                items[j] = new int[]{Integer.parseInt(str2[j]), Integer.parseInt(str3[j])};
            }

            //对数组排序
            Arrays.sort(items, comparator);

            //res保存最长递增子序列的大小。
            int result = 1;

            //用来保存每个长度末尾的Y尽可能小的[x,y]数组。
            //不使用dp[0]那一行；为了直观方便以人类逻辑的行为。
            int[][] dp = new int[row + 1][2];
            dp[1] = items[0];

            //二分法进行查找此时的Y刚刚好大于哪一个下标的Y，又小于下一个下标的Y，
            // 这样更改下一个下标的Y，为此时的Y，
            // 就可以保证dp数组保存的是末尾可能的最小的Y。
            // 这种方法相对于DP寻找最长递增子序列，更快，时间复杂度为O(nlogn)

            /*
            在x已经按从小到大排序后，我们有了现在排序后的items
            对于排序后的items，根据贪心算法，只要根据“把y按照尽量小得去排序”即可
             */
            for (int rowIndex = 1; rowIndex < row; rowIndex++) {

                if (dp[result][1] < items[rowIndex][1]) {

                    dp[++result] = items[rowIndex];

                } else if (dp[result][1] > items[rowIndex][1]) {

                    //compliantIndex就是可以插入items[rowIndex]这个对象的索引
                    int start = 1, end = result, compliantIndex = 0;

                    while (start <= end) {

                        int mid = (start + end) >> 1;
                        if (dp[mid][1] < items[rowIndex][1]) {
                            compliantIndex = mid;
                            start = mid + 1;
                        } else {
                            end = mid - 1;
                        }

                    }

                    if (dp[compliantIndex][0] != items[rowIndex][0]) {
                        dp[compliantIndex + 1] = items[rowIndex];
                    }
                }
            }



            System.out.println(result);
        }
    }
}
